import java.util.*;

/**
 * @author : niu niu
 * @version : 1.0.0
 * @date : 2023/4/6 9:40
 * 反转部分链表 -难点：自己构建单链表+ 反转过程使用头插法
 * 猴子分桃 -难点，数学思路的解决。long类型的选择
 */
class ListNode {
    int val;
    ListNode next;

    public ListNode(int val) {
        this.val = val;
        this.next = null;
    }
}
 public class Day28 {
    //猴子分桃
     public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
         int n = -1;
         while (scanner.hasNext()){
           n = scanner.nextInt();
           if (n==0){
               break;
           }
           solution(n);
        }
     }

     /**
      * 思路一 ： 借4个桃子给小猴子
      *     每次分5堆 会 多一个，所以我们借它4个，这样就可以完整的分5堆。 注意，分5堆，自己的那一堆 还是要给老猴子一个
      *     第一只小猴子拿走剩余 ： （X+4）* （4/5）
      *     第二只小猴子拿走剩余 ： （X+4）* （4/5）^2
      *     第三只小猴子拿走剩余 ： （X+4）* （4/5）^3
      *     第n只小猴子拿走剩余 ： （X+4）* （4/5）^n
      *     要使得 最后剩余的为整数，并且x最小： X+4 = 5^n
      *     X = 5^n - 4
      *     老猴子得到 ：  （X+4）* （4/5）^n + n - 4
      *                   4^n+n-4
      * 思路二 ：不借桃子
      *     每次都正常分。
      *      第一只小猴子拿走剩余 ： (X-1)*4/5= X*4/5 - 4/5
      *      第二只小猴子拿走剩余 ：  ( (X-1)*4/5 -1)4/5 =  X* (4/5)^2 - (4/5)^2 -4/5
      *      第三只小猴子拿走剩余 ：  X* (4/5)^3 - (4/5)^3 -4/5^2 - 4/5
      *      第n只小猴子拿走剩余 ： X* (4/5)^N - (4/5)^N -4/5^N-1 - 4/5.....
      *         利用等比数列求和： X * (4/5)^N -4(1-(4/5)^N)  = X * (4/5)^N - 4 +4(4/5)^N = (x+4)(4/5)^N - 4
      *      要使得 最后剩余的为整数，并且x最小： X-4 = 5^N
      *         x = 5^N-4
      *      老猴子得到： (x+4)(4/5)^N - 4 + N = 4 ^ N + N -4
      * @param n
      */
      public static void  solution(int n){
          long X = (long) Math.pow(5,n) -4;
          long oldMonkey = (long) Math.pow(4,n)+ n -4;
          System.out.println(X+" "+oldMonkey);
      }












//---------------------------------------- 反转部分链表 - 难点：自己构建单链表+ 反转过程使用头插法

    public static void main1(String[] args) {
        Scanner s = new Scanner(System.in);
        int length = s.nextInt();
        ListNode list = new ListNode(-1);
        ListNode tep = list;
        for (int i = 0; i < length; i++) {
            ListNode node = new ListNode(s.nextInt());
            tep.next = node;
            tep = node;
        }
        int left = s.nextInt();
        int right = s.nextInt();

        ListNode reverseList = reverse(list, left, right);
        reverseList= reverseList.next;
        while (reverseList!=null){
            System.out.print(reverseList.val + " ");
            reverseList= reverseList.next;
        }
    }
    private static ListNode reverse(ListNode list, int left, int right) {
        ListNode pre = list;
        ListNode cur = list;
        for (int i = 0; i < left-1; i++) {
            pre = pre.next;
        }
        cur = pre.next;
        for (int i = 0; i< right-left;i++){
            ListNode tep = cur.next;
            cur.next = tep.next;
            tep.next = pre.next;
            pre.next = tep;

        }
        
        return list;
    }

}


